home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
FishMarket 1.0
/
FishMarket v1.0.iso
/
fishies
/
101-125
/
disk_107
/
svtools
/
vnews
/
vnews.c
< prev
next >
Wrap
C/C++ Source or Header
|
1992-05-06
|
21KB
|
824 lines
/************************************************************
Vnews
Started by: Stephen Vermeulen 1987.
26-Aug-1987 This version has been Manxified.
Also some workbench support has been implemented.
This program is designed to be a simple news file reader.
The user invokes it with the name of the directory containing
the news files he wants to read. The program then allows
him to read these files easily.
Syntax from CLI:
vnews [dir_name [first_file]]
vnews dir_name
will display the contents of all the files in
the directory named dir_name.
vnews
will display the contents of all the files in
the current directory.
vnews dir_name first_file
will allow you to read all the files within the
directory "dir_name" and will start you at
file "first_file"
Syntax from Workbench:
Just point and click. To specify the directory to read the
news files from enter the following line into the TOOL TYPES
field:
DIR=MyDirectoryName
The default width that tabs are to be expanded to is specified
by the following line:
TAB=n
where n is a small positive number.
The reading can start with any particular file, just include
a line like:
FIRST=first_file_name
NOTE: some aspects of the code are clearly examples of how
not to code in C! Ie: I have made extensive and
unforgivable use of the GOTO statement...
************************************************************/
#include <intuition/intuition.h>
#include <graphics/gfxmacros.h>
#include <workbench/startup.h>
#include <workbench/workbench.h>
#include <stdio.h>
#include <functions.h>
#define PGUP 1
#define PGDN 2
#define NEXT 3
#define PREV 4
#define HELP 5
#define FILE_GAD 6
struct IntuitionBase *IntuitionBase; /* to use intuition functions */
struct GfxBase *GfxBase; /* to use graphics functions */
extern long IconBase;
extern struct WBStartup *WBenchMsg;
#define MAX_FILES 1000
/**************************************
Yuck, static list size in the Amiga?
Poor programming, bad boy, naughty...
Seriously though, since good old
Ami needs at least 2 blocks per file
and there are only 1800 blocks on a
floppy this should suffice for all
but nutty hard disk owners...
***************************************/
char *file_list[MAX_FILES];
/************************************************************
The following stuff sets up the window to be used to display
the text along with its gadgets that advance you through
the text of a single message, of from message to message.
The following gadgets are provided:
PgUp - display next page of the current message
PgDn - displays the previous page of the current message
Next - displays the next message
Prev - displays the previous message
These all live in the title bar, along with the name of
the file that is being displayed.
************************************************************/
#define LEFT_OFFSET 300
struct IntuiText pgup_text =
{
1, 0, JAM2, 0, 0, NULL, (UBYTE *) "Prev", NULL
};
struct IntuiText pgdn_text =
{
1, 0, JAM2, 0, 0, NULL, (UBYTE *) "back", NULL
};
struct IntuiText next_text =
{
1, 0, JAM2, 0, 0, NULL, (UBYTE *) "fore", NULL
};
struct IntuiText prev_text =
{
1, 0, JAM2, 0, 0, NULL, (UBYTE *) "Next", NULL
};
struct IntuiText help_text =
{
1, 0, JAM2, 0, 0, NULL, (UBYTE *) "?", NULL
};
struct Gadget pgup_gad =
{
NULL,
LEFT_OFFSET, 0, 32, 10,
GADGHCOMP, RELVERIFY | TOPBORDER, BOOLGADGET,
NULL, NULL,
&pgup_text,
NULL, NULL, PREV, NULL
};
struct Gadget pgdn_gad =
{
&pgup_gad,
LEFT_OFFSET+48, 0, 32, 10,
GADGHCOMP, RELVERIFY | TOPBORDER, BOOLGADGET,
NULL, NULL,
&pgdn_text,
NULL, NULL, PGDN, NULL
};
struct Gadget next_gad =
{
&pgdn_gad,
LEFT_OFFSET+96, 0, 32, 10,
GADGHCOMP, RELVERIFY | TOPBORDER, BOOLGADGET,
NULL, NULL,
&next_text,
NULL, NULL, PGUP, NULL
};
struct Gadget prev_gad =
{
&next_gad,
LEFT_OFFSET+144, 0, 32, 10,
GADGHCOMP, RELVERIFY | TOPBORDER, BOOLGADGET,
NULL, NULL,
&prev_text,
NULL, NULL, NEXT, NULL
};
struct Gadget help_gad =
{
&prev_gad,
LEFT_OFFSET+192, 0, 8, 10,
GADGHCOMP, RELVERIFY | TOPBORDER, BOOLGADGET,
NULL, NULL,
&help_text,
NULL, NULL, HELP, NULL
};
char file_string[32] = "";
struct StringInfo file_info =
{
(UBYTE *) &file_string,
NULL,
0, 30,
0, 0, 0, 0,
0, 0,
NULL, 0, NULL
};
struct Gadget file_gad =
{
&help_gad,
LEFT_OFFSET+208, 0, 78, 10,
GADGHCOMP, RELVERIFY | TOPBORDER, STRGADGET,
NULL, NULL,
NULL,
NULL,
(APTR) &file_info, FILE_GAD, NULL
};
struct NewWindow nw =
{
0, 3, 640, 200-3, /* we should go for the max in case morerows was used */
-1, -1,
GADGETUP | CLOSEWINDOW,
WINDOWDEPTH | WINDOWCLOSE | SMART_REFRESH | BORDERLESS | ACTIVATE,
&file_gad,
NULL,
NULL,
NULL, /* default screen */
NULL, /* no special bm */
0, 0, -1, -1,
WBENCHSCREEN
};
struct NewWindow new_help =
{
168, 47, 304, 110,
-1, -1,
CLOSEWINDOW,
WINDOWDEPTH | WINDOWCLOSE | SMART_REFRESH,
NULL,
NULL,
(UBYTE *) "Vnews Help",
NULL, /* default screen */
NULL, /* no special bm */
0, 0, -1, -1,
WBENCHSCREEN
};
/************************************************************
This array is used to hold offsets from the start of the
file to the nth page in it, so the PgDn function works, as
the file is paged through by hitting PgUp the position of
each page start is entered into the array, then when PgDn
is hit you can easily backup.
************************************************************/
unsigned long int page_top[MAX_FILES];
short current_page; /* index for the page_top array */
short current_file; /* index for the file name array */
struct Window *w;
FILE *in;
/************************************************************
The display_page() function displays a page of text from
the file on the screen. It first clears the window, then
it does a line by line display of the file, it reads from
the line one line of text at a time, printing each line of
text to the window and then advancing to the next line on
the window, when it has printed 23 lines of text the process
stops.
************************************************************/
char temp_buf[200];
/************************************************************
The clean_string function removes CR's from the text string
and expands tabs out to tabwidth spaces each.
Note the value for tabwidth can only be specified if the
program is started from the workbench.
************************************************************/
short tabwidth;
void clean_string(s)
register char *s;
{
register int n;
register int i, j, k;
n = strlen(s);
if (n)
{
if (index(s, 10) || index(s, 13) || index(s, 9))
{
for (i = 0; i < n; ++i)
{
switch(s[i])
{
case 10: /* line feed -- replace with space */
case 13: /* carriage return -- replace with space */
s[i] = ' ';
break;
case 9: /* tab -- expand to tabwidth spaces */
s[i] = ' ';
if (tabwidth > 1)
{
/*****************************
First figure out how far to
the next tab stop.
******************************/
k = tabwidth - (i % tabwidth);
if (k > 1)
{
movmem(s + i + 1, s + i + k, n - i);
for (j = 1; j < k; ++j)
s[i+j] = ' ';
n += k;
}
}
break;
}
}
}
}
}
void display_page()
{
int dy;
SetAPen(w->RPort, 0L);
RectFill(w->RPort, 0L, (long) w->BorderTop + 1,
(long) w->Width - 1, (long) w->Height - w->BorderBottom);
SetAPen(w->RPort, 1L);
dy = w->RPort->TxHeight;
Move(w->RPort, 0L, (long) w->BorderTop + dy);
while((w->RPort->cp_y + dy) < w->Height) /* enough room */
{
if (fgets(temp_buf, 80, in))
{
temp_buf[80] = 0; /* always force an end of string here
as fgets does not put one in if 80
characters were read before any
end of line type character was hit
*/
clean_string(temp_buf);
/*********************************************
This is not the best way of doing it, because
lines that are longer than about 80 characters
get truncated. One should really break long
lines appropriately so that all the text does
get displayed.
This problem has been partially eliminated
by reading in only 80 character chunks from
the file by the fgets() function. This is
not the true solution because it depends on the
font that is being used.
*********************************************/
Text(w->RPort, temp_buf, (long) strlen(temp_buf));
w->RPort->cp_x = 0;
w->RPort->cp_y += dy;
}
else /* we have reached EOF */
{
clean_string(temp_buf);
Text(w->RPort, temp_buf, (long) strlen(temp_buf));
goto eof_stop;
}
}
eof_stop:
return;
}
/************************************************************
The next_page() function has three modes depending on the
value of n:
-1 - Move to the previous page and display one page of the
file.
0 - Display the file from the very first line.
+1 - Move the file to the next page and display it.
************************************************************/
void next_page(n)
short n;
{
unsigned long int pos;
if (!in) return;
switch(n)
{
case -1:
if (current_page) --current_page;
fseek(in, page_top[current_page], 0);
display_page();
break;
case 0:
current_page = 0;
page_top[0] = 0;
display_page();
break;
case 1:
pos = ftell(in);
if (pos != EOF)
{
if (current_page < MAX_FILES) ++current_page;
page_top[current_page] = pos;
display_page();
}
break;
}
}
/************************************************************
The next file function has three modes depending on the
value of n:
-1 - Move to the previous file in the file list.
0 - Open the very first file in the file list.
+1 - Move to the next file in the file list.
*************************************************************/
void next_file(n)
short n;
{
switch(n)
{
case -1:
if (current_file) --current_file;
if (in) fclose(in);
in = fopen(file_list[current_file], "r");
break;
case 0:
current_file = 0;
in = fopen(file_list[current_file], "r");
break;
case 1:
if (current_file < MAX_FILES) ++current_file;
if (in) fclose(in);
in = fopen(file_list[current_file], "r");
break;
}
if (in)
{
SetWindowTitles(w, file_list[current_file], -1L);
}
else
{
SetWindowTitles(w, "No more news!", -1L);
}
}
extern char *scdir();
extern char *malloc();
/******************************
Function to compare strings
******************************/
compare(a, b)
char **a, **b;
{
return(strcmp(*a, *b));
}
/***************************************
this function scans the current
directory, using the "pattern" string,
placing pointers to the file names in
the file_names array, it allocates the
nessecary string space, up to a maximum
of nmax strings.
Oh yes, it sorts the strings with the
function comp too.
*****************************************/
get_dir(pattern, file_names, nmax, comp)
char *pattern, *file_names[];
short nmax;
short (*comp)();
{
char *s;
int i, j;
/*********************************
Paranoia time, zero all pointers
manually...
**********************************/
for (i = 0; i < nmax; ++i)
file_names[i] = 0;
i = 0;
while((s = scdir(pattern)) && (i < nmax))
{
if (file_names[i] = malloc(strlen(s) + 1))
{
strcpy(file_names[i], s);
++i;
}
}
/******************************************
Now sort the file lists that have been
built up.
******************************************/
qsort(file_names, i, 4, comp);
}
/**********************************************
this function frees up the space taken by the
copys of the strings.
***********************************************/
free_strings(file_names, nmax)
char *file_names[];
short nmax;
{
short j;
j = 0;
while (file_names[j])
{
free(file_names[j]);
++j;
}
}
/************************************************
This is a function that gets a value from a
tool type field. You give it a toolarry pointer
a tooltype string and a conversion string and
a pointer of where to put the result.
*************************************************/
getToolValue(ta, tt, cs, x)
char **ta;
char *tt, *cs, *x;
{
char *s;
if (s = FindToolType(ta, tt))
sscanf(s, cs, x);
}
/************************************************
The following is a function that returns TRUE
is a certain tool type mode is set.
*************************************************/
isToolModeSet(ta, tt, tm)
char **ta, *tt, *tm;
{
char *s;
if (s = FindToolType(ta, tt))
return((short) MatchToolValue(s, tm));
return(0);
}
char start_name[90], directory[90], temp[90], dir_path[90];
void main(argc, argv)
int argc;
char *argv[];
{
int flag;
int func, class, i;
struct IntuiMessage *mess;
struct Screen wb_screen;
struct Window *hw;
char **toolarray;
struct WBArg *arg;
struct DiskObject *diskobj;
IntuitionBase = (struct IntuitionBase *)
OpenLibrary("intuition.library", 0L);
if (!IntuitionBase) goto no_intuition;
GfxBase = (struct GfxBase *) OpenLibrary("graphics.library", 0L);
if (!GfxBase) goto no_graphics;
IconBase = (long) OpenLibrary("icon.library", 0L);
if (!IconBase) goto no_icons;
tabwidth = 2;
start_name[0] = 0;
dir_path[0] = 0;
/**************************
Are we running from CLI
or the Workbench?
**************************/
if (argc)
{
/************************
Running from the CLI
************************/
if (argc > 1)
{
strcpy(start_name, argv[1]);
strcpy(dir_path, argv[1]);
if (start_name[strlen(start_name) - 1] == ':')
strcat(start_name, "*");
else
{
strcat(start_name, "/*");
strcat(dir_path, "/");
}
}
else
strcpy(start_name, "*");
get_dir(start_name, file_list, MAX_FILES, compare);
if (argc > 2)
{
strcpy(start_name, argv[1]);
if (start_name[strlen(start_name) - 1] == ':')
strcat(start_name, argv[2]);
else
{
strcat(start_name, "/");
strcat(start_name, argv[2]);
}
}
else
start_name[0] = 0;
}
else
{
/****************************
Running from the Workbench
Arg will always point to the
tool's icon. So what we must
do is scan this tool type
array to read in the name of
the directory to use and the
name of the first file to
start with and the tab size.
*****************************/
arg = WBenchMsg->sm_ArgList;
/**************************************
First we change our current directory
to the location of the program. This
is needed in case the user just specifies
a relative directory path name.
***************************************/
(void) CurrentDir(arg->wa_Lock);
diskobj = GetDiskObject(arg->wa_Name);
/*********************************
now parse the tooltypes array
**********************************/
directory[0] = 0;
temp[0] = 0;
if (diskobj)
{
toolarray = diskobj->do_ToolTypes;
getToolValue(toolarray, "TAB", "%d", &tabwidth);
getToolValue(toolarray, "DIR", "%s", directory);
getToolValue(toolarray, "FIRST", "%s", temp);
FreeDiskObject(diskobj);
}
if (temp[0])
{
strcpy(start_name, directory);
strcpy(dir_path, directory);
if (start_name[strlen(start_name) - 1] == ':')
strcat(start_name, temp);
else
{
strcat(start_name, "/");
strcat(dir_path, "/");
strcat(start_name, temp);
}
}
if (directory[strlen(directory) - 1] == ':')
strcat(directory, "*");
else
strcat(directory, "/*");
get_dir(directory, file_list, MAX_FILES, compare);
}
/****************************************
The directory has now been read and sorted
it is time to walk through the files.
Lets open the window so that it makes full
use of the workbench screen.
****************************************/
GetScreenData(&wb_screen, (long) sizeof(struct Screen), WBENCHSCREEN, NULL);
nw.Width = wb_screen.Width;
nw.Height = wb_screen.Height - 3;
w = (struct Window *) OpenWindow(&nw);
if (!w) goto no_window; /* can't open window error */
if (start_name[0]) /* start at this file */
{
current_file = 0;
while (strcmp(start_name, file_list[current_file]) &&
file_list[current_file]) ++current_file;
--current_file;
next_file(1);
next_page(0);
}
else
{
next_file(0); /* open a new file (the first) for display */
next_page(0); /* display the next page in this file */
}
flag = TRUE;
while(flag)
{
Wait(1L << w->UserPort->mp_SigBit);
while(mess = (struct IntuiMessage *) GetMsg(w->UserPort))
{
func = ((struct Gadget *) mess->IAddress)->GadgetID;
class = mess->Class;
ReplyMsg(mess);
if (class == CLOSEWINDOW) flag = FALSE;
switch(func)
{
case PGUP:
if (feof(in))
{
next_file(1);
next_page(0);
}
else
next_page(1);
break;
case PGDN:
if (current_page == 0)
{
next_file(-1);
next_page(0);
}
else
next_page(-1);
break;
case NEXT:
next_file(1);
next_page(0);
break;
case PREV:
next_file(-1);
next_page(0);
break;
case HELP:
if (hw = OpenWindow(&new_help))
{
Move(hw->RPort, 4L, 18L);
Text(hw->RPort, "------------ Vnews 1.1 -----------", 36L);
Move(hw->RPort, 4L, 26L);
Text(hw->RPort, "By: Stephen Vermeulen (403) 282-7990", 36L);
Move(hw->RPort, 4L, 34L);
Text(hw->RPort, " Copyright 1987 ", 36L);
Move(hw->RPort, 4L, 42L);
Text(hw->RPort, "This program is in the public domain", 36L);
Move(hw->RPort, 4L, 50L);
Text(hw->RPort, "except it may not be sold or packaged", 37L);
Move(hw->RPort, 4L, 58L);
Text(hw->RPort, "with a commercial product. ", 36L);
Move(hw->RPort, 4L, 66L);
Text(hw->RPort, "To use just click on the title bar ", 36L);
Move(hw->RPort, 4L, 74L);
Text(hw->RPort, "icons:", 6L);
Move(hw->RPort, 4L, 82L);
Text(hw->RPort, "Prev gets you to the previous file ", 36L);
Move(hw->RPort, 4L, 90L);
Text(hw->RPort, "Back moves backwards one page ", 36L);
Move(hw->RPort, 4L, 98L);
Text(hw->RPort, "Fore moves foward one page ", 36L);
Move(hw->RPort, 4L, 106L);
Text(hw->RPort, "Next gets you to the next file ", 36L);
Wait(1L << hw->UserPort->mp_SigBit);
while(mess = (struct IntuiMessage *) GetMsg(hw->UserPort))
ReplyMsg(mess);
CloseWindow(hw);
}
break;
case FILE_GAD:
/**************************************
Get a filename to go to from the user
The user has already typed it in, so
process it. Note we will have to
preference it with the directory path!
***************************************/
strcpy(start_name, dir_path);
strcat(start_name, file_string);
if (start_name[0]) /* start at this file */
{
current_file = 0;
while (strcmp(start_name, file_list[current_file]) &&
file_list[current_file]) ++current_file;
--current_file;
next_file(1);
next_page(0);
}
break;
}
} /* end of while more messages */
} /* end of while(flag) */
CloseWindow(w);
no_window:
dir_error:
free_strings(file_list, MAX_FILES);
no_files:
CloseLibrary(IconBase);
no_icons:
CloseLibrary(GfxBase);
no_graphics:
CloseLibrary(IntuitionBase);
no_intuition:
return;
}